home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource3 / 172_01 / outa.c < prev    next >
Text File  |  1979-12-31  |  11KB  |  310 lines
  1. /*
  2.   HEADER:              CUG  nnn.nn;
  3.   TITLE:               LEX - A Lexical Analyser Generator
  4.   VERSION:             1.1 for IBM-PC
  5.   DATE:                Jan 30, 1985
  6.   DESCRIPTION:         A Lexical Analyser Generator. From UNIX
  7.   KEYWORDS:            Lexical Analyser Generator YACC C PREP
  8.   SYSTEM:              IBM-PC and Compatiables
  9.   FILENAME:            OUTA.C
  10.   WARNINGS:            This program is not for the casual user. It will
  11.                        be useful primarily to expert developers.
  12.   CRC:                 N/A
  13.   SEE-ALSO:            YACC and PREP
  14.   AUTHORS:             Charles H. Forsyth
  15.                        Scott Guthery 11100 leafwood lane Austin, TX 78750
  16.                        Andrew M. Ward, Jr.  Houston, Texas (Modifications)
  17.   COMPILERS:           LATTICE C
  18.   REFERENCES:          UNIX Systems Manuals -- Lex Manual on distribution disks
  19. */
  20. /*
  21.  * Copyright (c) 1978 Charles H. Forsyth
  22.  *
  23.  * Modified 02-Dec-80 Bob Denny -- Conditionalize debug code for smaller size
  24.  *                           01 -- Removed ending() function code from here
  25.  *                                  to lex.c, so ytab.c code could share the
  26.  *                                  same overlay region as this module.
  27.  *                           02 -- Removed nfaprint(), llactr(), newcase(),
  28.  *                                  cclprint(), chprint() and setline(),
  29.  *                                  the rest of this can share an overlay.
  30.  *                                  They're in 'out2.c'. This is now 'out1.c'.
  31.  *          29-May-81 Bob Denny -- More extern hacking for RSX overlaying.
  32.  *          19-Mar-82 Bob Denny -- New compiler and library
  33.  *          03-May-82 Bob Denny -- Final touches, remove unreferenced autos
  34.  *          28-Aug-82 Bob Denny -- Put "=" into table initializers to make
  35.  *                                  new compiler happy. Add "-s" code to
  36.  *                                  supress "#include <stdio.h>" in output.
  37.  *                                  Tables output 8 values/line instead of
  38.  *                                  16.  Overran R.H. edge on 3 digit octals.
  39.  *                                  Change output format for readability.
  40.  *          31-Aug-82 Bob Denny -- Add lexswitch( ...) to llstin so table
  41.  *                                 name selected by -t switch is automatically
  42.  *                                 switched-to at yylex() startup time. Removed
  43.  *                                  hard reference to "lextab" from yylex();
  44.  *                                  This module generates extern declaration
  45.  *                                  for forward reference.
  46.  *          14-Apr-83 Bob Denny -- Add VAX11C support.  Remove usage of remote
  47.  *                                  formats (damn!) not supported on VAX-11 C.
  48.  *                                 Use "short int" for 16-bit table items under
  49.  *                                  VAX-11 C to save size.
  50.  *                                 Contitional out flaky debug code.  Probably
  51.  *                                  related to non-functional minimization.
  52.  *            20-Nov-83 Scott Guthery -- Adapt for IBM PC & DeSmet C
  53.  *            26-Dec-83 Scott Guthery -- Removed "extern FILE lexin" from llstin
  54.  *                           code and put it lex.h.
  55.  *          22-Jun-86 Andrew M. Ward -- Modified code to emit proper header info
  56.  *                                      for Lattice C.
  57.  */
  58.  
  59. /*
  60.  * lex -- output human- and machine-readable tables
  61.  */
  62.  
  63. #include "stdio.h"
  64. #include "lexlex.h"
  65.  
  66. extern struct dfa dfa[];
  67. extern char *ignore;
  68. extern char infile[];
  69. extern char *illeg;
  70. extern char *breakc;
  71. extern int nlook;
  72. extern void dospccl(char *, char *, char *);
  73. extern void refccl(char *, char *, char *);
  74. extern void vstart(char *, char *), vend(void), vel(char *, int);
  75. extern void heading(void);
  76. extern int  ndfa;
  77. int ven=0;
  78. char strdec1[] = "\nstruct lextab %s =\t{\n";
  79. char strdec2[] = "\t\t\t%d,\t\t/* Highest state */\n";
  80. char strdec3[] = "\t\t\t_D%s\t/* --> \"Default state\" table */\n";
  81. char strdec4[] = "\t\t\t_N%s\t/* --> \"Next state\" table */\n";
  82. char strdec5[] = "\t\t\t_C%s\t/* --> \"Check value\" table */\n";
  83. char strdec6[] = "\t\t\t_B%s\t/* --> \"Base\" table */\n";
  84. char strdec7[] = "\t\t\t%d,\t\t/* Index of last entry in \"next\" */\n";
  85. char strdec8[] = "\t\t\t%s,\t\t/* --> Byte-int move routine */\n";
  86. char strdec9[] = "\t\t\t_F%s\t/* --> \"Final state\" table */\n";
  87. char strdec10[] = "\t\t\t_A%s\t/* --> Action routine */\n";
  88. char strdec11[] = "\n\t\t\t%s%s\t/* Look-ahead vector */\n";
  89.  
  90.  
  91. char ptabnam[] = { "         " };
  92.  
  93. /*
  94.  * Print the minimised DFA, and at the same time, construct the vector which
  95.  * indicates final states by associating them with their translation index.
  96.  * (DFA printout supressed ifndef DEBUG.)
  97.  */
  98.  
  99. void dfaprint()
  100. {
  101.        struct dfa *st;
  102.        int i, fi, k, l;
  103.  
  104.        vstart("LL16BIT _F%s", tabname);
  105.        for(i = 0; i < ndfa; i++) {
  106.                st = &dfa[i];
  107.                k = -1;
  108.                if(fi = st->df_name->s_final) {
  109.                        k = nfa[fi].n_trans - trans;
  110.                        if (nfa[fi].n_flag & FLOOK) {
  111.                                 k |= (nfa[fi].n_look+1)<<11;
  112.                        }
  113.                 }
  114.                if(l = st->df_name->s_look)
  115.                        ;
  116.                vel(" %d,", k);
  117.        }
  118.        vel(" %d,", -1);        /* blocking state */
  119.  
  120.        vend();
  121. }
  122.  
  123.  
  124. void heading()
  125. {
  126.        fprintf(llout,
  127.         "/*\n * Created by IBM PC LEX from file \"%s\"\n", infile);
  128.        if(sflag == 0)                  /* If "standalone" switch off */
  129.                {
  130.                fprintf(llout,
  131.                        " *\t- for use with standard I/O\n */\n");
  132.                fprintf(llout, "\n");
  133.                }
  134.        else
  135.                fprintf(llout, " *\t- for use with stand-alone I/O\n */\n");
  136.  
  137.        fprintf(llout, "#include \"lex.h\"\n");
  138.        fprintf(llout, "#define LL16BIT int\n");
  139.        fprintf(llout, "extern int _lmov%c();\n",
  140.                        (ndfa <= 255) ? 'b' : 'i');
  141.                fprintf(llout, "extern struct lextab *_tabp;\n");
  142.                fprintf(llout, "int lexval;\n");
  143.                fprintf(llout, "extern int yyline;\n");
  144.                fprintf(llout, "extern char *llend;\n");
  145.                fprintf(llout, "extern void llstin();\n");
  146.                fprintf(llout, "char *lbuf;\n");
  147. }
  148.  
  149. void dfawrite()
  150. {
  151.        struct move *dp;
  152.        int i, a, kk;
  153.        struct dfa *st, *def;
  154.        struct set *xp;
  155.        char *xcp;
  156.  
  157.        setline();
  158.        fprintf(llout,
  159.                "\n#define\tLLTYPE1\t%s\n", ndfa <= 255 ? "char" : "LL16BIT" );
  160.  
  161.        vstart("LLTYPE1 _N%s", tabname);
  162.  
  163.        for (i = 0; i <= llnxtmax; i++)
  164.                if( ( xp = move[i].m_next) != NULL )
  165.                {
  166.                       kk = xp->s_state - &dfa[0];
  167.                       vel(" %d,", kk );
  168.                }
  169.                else
  170.                       vel(" %d,", ndfa);
  171.        vend();
  172.  
  173.        vstart("LLTYPE1 _C%s", tabname);
  174.        for (i = 0; i <= llnxtmax; i++)
  175.                if( ( st = move[i].m_check) != NULL )
  176.                {
  177.                       kk = st - &dfa[0];
  178.                       vel(" %d,", kk );
  179.                }
  180.                else
  181.                        vel(" %d,", -1);
  182.        vend();
  183.  
  184.        vstart("LLTYPE1 _D%s", tabname);
  185.        for (i = 0; i < ndfa; i++)
  186.                if( ( def = dfa[i].df_default) != NULL )
  187.                {
  188.                        kk = def - dfa;
  189.                        vel(" %d,", kk );
  190.                }
  191.                else
  192.                        vel(" %d,", ndfa); /* refer to blocking state */
  193.        vend();
  194.  
  195.        vstart("LL16BIT _B%s", tabname);
  196.        for (i = 0; i < ndfa; i++)
  197.                if( (dp = dfa[i].df_base) != NULL )
  198.                {
  199.                        kk = dp - &move[0];
  200.                        vel(" %d,", kk );
  201.                }
  202.                else
  203.                        vel(" %d,", 0);
  204.        vel(" %d,", 0); /* for blocking state */
  205.        vend();
  206.  
  207.        if( nlook )
  208.        {
  209.                fprintf(llout, "char    *llsave[%d];\n", nlook);
  210.                vstart("LL16BIT _L%s", tabname);
  211.                a = nlook <= NBPC ? NCHARS-1 : -1;
  212.                for (i = 0; i < ndfa; i++)
  213.                        vel(" 0%o,", dfa[i].df_name->s_look & a);
  214.                vel(" %d,", 0);
  215.                vend();
  216.        }
  217.  
  218.        dospccl(ignore, "LLIGN", "X");
  219.        dospccl(breakc, "LLBRK", "Y");
  220.        dospccl(illeg, "LLILL", "Z");
  221.  
  222.        strcpy(ptabnam, tabname); strcat(ptabnam,",");
  223.        fprintf(llout, strdec1, tabname);
  224.        fprintf(llout, strdec2, ndfa);
  225.        fprintf(llout, strdec3, ptabnam);
  226.        fprintf(llout, strdec4, ptabnam);
  227.        fprintf(llout, strdec5, ptabnam);
  228.        fprintf(llout, strdec6, ptabnam);
  229.        fprintf(llout, strdec7, llnxtmax);
  230.        fprintf(llout, strdec8, ndfa<=255?"_lmovb":"_lmovi");
  231.        fprintf(llout, strdec9, ptabnam);
  232.        fprintf(llout, strdec10, ptabnam);
  233.        fprintf(llout, strdec11, nlook?"_L":"", nlook?ptabnam:"NULL,   ");
  234.  
  235.        refccl(ignore, "Ignore", "X");
  236.        refccl(breakc, "Break", "Y");
  237.        refccl(illeg, "Illegal", "Z");
  238.        fprintf(llout, "\t\t\t};\n");
  239.  
  240.        if(sflag == 0)                  /* If stdio flavor */
  241.                {
  242.                fprintf(llout, "\n/* Standard I/O selected */\n");
  243.  
  244.                fprintf(llout, "FILE *lexin = NULL;\n\n");
  245.                fprintf(llout, "\nextern struct lextab *lexswitch();");
  246.                fprintf(llout, "\nvoid llstin()\n   {\n   if((FILE *)lexin == NULL)\n");
  247.                fprintf(llout, "      lexin = stdin;\n");
  248.                }
  249.        else                            /* Stand-alone flavor */
  250.                {
  251.                fprintf(llout, "\n/* Stand-alone selected */\n");
  252.                fprintf(llout, "\llstin()\n   {\n");
  253.                }
  254.  
  255.        fprintf(llout, "   if(_tabp == NULL)\n");
  256.        fprintf(llout, "      lexswitch(&%s);\n   }\n\n", tabname);
  257.        fclose(llout);
  258. }
  259.  
  260. void dospccl(cp, s, tag)
  261. char *cp;
  262. char *s, *tag;
  263. {
  264.        int n;
  265.        char cclnam[16];
  266.  
  267.        if (cp==0)
  268.                return;
  269.        fprintf(llout, "#define\t%s\t%s\n", s, tag);
  270.        strcpy(cclnam, tag); strcat(cclnam, tabname);
  271.        vstart("char _%s", cclnam);
  272.        for (n = sizeof(ccls[0]); n--;)
  273.  
  274.                vel(" 0%o,", *cp++&CMASK );
  275.        vend();
  276. }
  277.  
  278. void refccl(cp, nm, tag)
  279. char *cp, *nm, *tag;
  280. {
  281.        if (cp==0)
  282.                fprintf(llout, "\t\t\tNULL,\t\t/* No %s class */\n", nm);
  283.        else
  284.                fprintf(llout, "\t_%s%s,\t/* %s class */\n", tag, tabname, nm);
  285. }
  286.  
  287. void vstart(fmt, str)
  288. char *fmt;
  289. char *str;              /*** WATCH IT ***/
  290. {
  291.        putc('\n', llout);
  292.        ven = 0;
  293.        fprintf(llout, fmt, str);
  294.        fprintf(llout, "[] =\n   {\n  ");
  295. }
  296.  
  297. void vend()
  298. {
  299.        fprintf(llout, "\n   };\n");
  300. }
  301.  
  302. void vel(fmt, val)
  303. char *fmt;
  304. int val;                /*** WATCH IT ***/
  305. {
  306.        fprintf(llout, fmt, val);
  307.        if((++ven&07)==0)
  308.                fprintf(llout, "\n  ");
  309. }
  310.